home *** CD-ROM | disk | FTP | other *** search
/ RISC User... in a Nutshell / RISC User... in a Nutshell.iso / !Nutshell / !OvnPro / Library / !MenuLib < prev    next >
Encoding:
Text File  |  1998-05-29  |  29.2 KB  |  1,825 lines
  1. /*->$.Q.!OvnPro.Library.!MenuLib */
  2.  
  3. int tick;
  4.  
  5. /****************************************************************/
  6.  
  7. int main_handle;
  8.  
  9. int main_flags(int entry,string & text)
  10. {
  11.  switch(entry)
  12.  {
  13.   case 3:
  14.          text=content_name();
  15.          break;
  16.  }
  17.  return(0);
  18. }
  19.  
  20. int main_menu(int open)
  21. {
  22.  return(main_handle);
  23. }
  24.  
  25. /****************************************************************/
  26.  
  27. int file_handle;
  28.  
  29. int file_entry(int entry,int subcode)
  30. {
  31.  switch(entry)
  32.  {
  33.   case 0:
  34.          open_menu(fileinfo_box(1));
  35.          break;
  36.   case 1:
  37.          if(subcode==-2) open_menu(savedocument_box(1));
  38.          else
  39.          if(subcode==-1) savedocument("");
  40.          break;
  41.  
  42.  
  43.  }
  44.  return(0);
  45. }
  46.  
  47. int file_flags(int entry,string & text)
  48. {
  49.  switch(entry)
  50.  {
  51.   case 0:
  52.          return(DOTTED);
  53.          break;
  54.   case 2:
  55.          return(export_name(text)?0:SHADED);
  56.          break;
  57.   case 4:
  58.          return((issaved() && ischanged())?DOTTED:SHADED|DOTTED);
  59.          break;
  60.   case 6:
  61.          return(DOTTED);
  62.          break;
  63.  }
  64.  return(0);
  65. }
  66.  
  67. int file_menu(int open)
  68. {
  69.  return(file_handle);
  70. }
  71.  
  72.  
  73. /****************************************************************/
  74.  
  75. int edit_handle;
  76.  
  77. int edit_flags(int entry,string & text)
  78. {
  79.  int bits;
  80.  
  81.  bits=SHADED;
  82.  
  83.  switch(entry)
  84.  {
  85.   case 0:
  86.          text=text+" "+undostring();
  87.          if(canundo()) bits=0;
  88.          break;
  89.   case 1:
  90.          bits=SHADED | DOTTED;
  91.          text=text+" "+redostring();
  92.          if(canredo()) bits=DOTTED;
  93.          break;
  94.   case 2:
  95.          text=text+" "+selection_name();
  96.          if(cancopy() && candelete()) bits=0;
  97.          break;
  98.   case 3:
  99.          text=text+" "+selection_name();
  100.          if(cancopy()) bits=0;
  101.          break;
  102.   case 4:
  103.          text=text+" "+paste_name();
  104.          if(cliptype()>=0) bits=0;
  105.          break;
  106.   case 5:
  107.          text=text+" "+selection_name();
  108.          if(candelete()) bits=0;
  109.          break;
  110.   case 6:
  111.          bits=SHADED | DOTTED;
  112.          if(cliptype()==0) bits=DOTTED;
  113.          break;
  114.   case 8:
  115.          bits=SHADED | DOTTED;
  116.          if(nselected()) bits=DOTTED;
  117.          break;
  118.   case 9:
  119.          if(activetype(TEXTFRAME)>1) bits=0;
  120.          break;
  121.  }
  122.  return(bits);
  123. }
  124.  
  125. int edit_menu(int open)
  126. {
  127.  return(edit_handle);
  128. }
  129.  
  130. /****************************************************************/
  131.  
  132. int view_handle;
  133.  
  134. int view_entry(int entry,int subcode)
  135. {
  136.  switch(entry)
  137.  {
  138.   case 1:
  139.          if(subcode==-2) open_menu(view_box(1));
  140.          break;
  141.   case 2:
  142.          if(subcode==-2) open_menu(grid_box(1));
  143.          break;
  144.   case 3:
  145.          if(subcode==-2) open_menu(zoom_box(1));
  146.          break;  
  147.  }
  148.  return(0);
  149. }
  150.  
  151. int view_flags(int entry,string & text)
  152. {
  153.  switch(entry)
  154.  {
  155.   case 0:
  156.          return(DOTTED);
  157.          break;
  158.  }
  159.  return(0);
  160. }
  161.  
  162. int view_menu(int open)
  163. {
  164.  return(view_handle);
  165. }
  166.  
  167. /****************************************************************/
  168.  
  169. int text_handle;
  170.  
  171. int text_flags(int entry,string & text)
  172. {
  173.  int bits;
  174.  
  175.  bits=(activetype(TEXTFRAME)>1)?0:SHADED;
  176.  
  177.  switch(entry)
  178.  {
  179.   case 4:
  180.          bits|=DOTTED;
  181.          break;
  182.  }
  183.  return(bits);
  184. }
  185.  
  186. int text_menu(int open)
  187. {
  188.  return(text_handle);
  189. }
  190.  
  191. /****************************************************************/
  192.  
  193. int case_handle;
  194.  
  195. int case_entry(int entry,int subcode)
  196. {
  197.  setcase(entry);
  198.  return(0);
  199. }
  200.  
  201. int case_flags(int entry,string & text)
  202. {
  203.  return(entry==getcase());
  204. }
  205.  
  206. int case_menu(int open)
  207. {
  208.  return(case_handle);
  209. }
  210.  
  211. /****************************************************************/
  212.  
  213. int tint_handle;
  214.  
  215. int tint_entry(int entry,int subcode)
  216. {
  217.  int utint;
  218.  
  219.  utint=stoi(string_menu(tint_handle,entry));
  220.  settint(utint);
  221.  return(0);
  222. }
  223.  
  224. int tint_flags(int entry,string & text)
  225. {
  226.  int tint;
  227.  
  228.  tint=gettint();
  229.  
  230.  switch(entry)
  231.  {
  232.   case 10:
  233.           text=tick ? "" : itos(tint);
  234.           return((8<<24)|(8<<16)|WRITEABLE|!tick);
  235.           break;
  236.   case  0:
  237.           tick=0;
  238.   default:
  239.           if(tint==stoi(text)) return(tick=1);
  240.           break;
  241.  }
  242.  return(0);         
  243. }
  244.  
  245. int tint_menu(int open)
  246. {
  247.  return(tint_handle);
  248. }
  249.  
  250. /****************************************************************/
  251.  
  252. int ulinewidth_handle;
  253.  
  254. int ulinewidth_entry(int entry,int subcode)
  255. {
  256.  switch(entry)
  257.  {
  258.   case 0:
  259.          setulwidth("2%");
  260.          break;
  261.   case 1:
  262.          setulwidth("4%");
  263.          break;
  264.   case 2:
  265.          setulwidth("8%");
  266.          break;
  267.   case 3:
  268.          setulwidth(string_menu(ulinewidth_handle,3));
  269.          break;
  270.  }
  271.  return(0);
  272. }
  273.  
  274. int ulinewidth_flags(int entry,string & text)
  275. {
  276.  string width;
  277.  
  278.  getulwidth(width);
  279.  
  280.  switch(entry)
  281.  {
  282.   case 0:
  283.          tick=0;
  284.          if(width=="2%") return(tick=1);
  285.          break;
  286.   case 1:
  287.          if(width=="4%") return(tick=1);
  288.          break;
  289.   case 2:
  290.          if(width=="8%") return(tick=1);
  291.          break;
  292.   case 3:
  293.          text=tick ? "" : width;
  294.          return((8<<24)|(8<<16)|WRITEABLE|!tick);
  295.          break;
  296.  }
  297.  return(0);
  298. }
  299.  
  300. void ulinename(string & width)
  301. {
  302.  if(width=="2%")  width="{UWM01}";
  303.  else
  304.  if(width=="4%")  width="{UWM02}";
  305.  else
  306.  if(width=="8%")  width="{UWM03}";
  307.  translate(width);
  308. }
  309.  
  310. int ulinewidth_menu(int open)
  311. {
  312.  return(ulinewidth_handle);
  313. }
  314.  
  315. /****************************************************************/
  316.  
  317. int font_handle;
  318. int font_subhandle;
  319.  
  320.  
  321. int font_subentry(int entry,int subcode)
  322. {
  323.  return(entry);
  324. }
  325.  
  326.  
  327. int font_subflags(int entry,string & text)
  328. {
  329.  return(menuprevious(0)==getfont() && entry==getsubfont());
  330. }
  331.  
  332.  
  333. int font_submenu(int open)
  334. {
  335.  int    i;
  336.  string s;
  337.  int    previous;
  338.                  
  339.  previous=menuprevious(0);
  340.  
  341.  if(font_subhandle) delete_menu(font_subhandle);
  342.  
  343.  getfontname(previous,s);
  344.  font_subhandle=create_menu(s);
  345.  
  346.  i=0;
  347.  while(getfontsubname(previous,i++,0,s))
  348.    addentryl_menu(font_subhandle,"font_subentry","font_subflags","","",s);
  349.  
  350.  return(font_subhandle);
  351. }
  352.  
  353.  
  354. int font_entry(int entry,int subcode)
  355. {
  356.  setsubfont(entry,subcode);
  357.  return(0);
  358. }
  359.  
  360. int font_flags(int entry,string & text)
  361. {
  362.  return(entry==getfont());
  363. }
  364.  
  365.  
  366. int font_menu(int open)
  367. {
  368.  int    i;
  369.  int    sub;
  370.  string s;
  371.  string r;
  372.  
  373.  if(fontschanged() || !font_handle)
  374.  {
  375.   if(font_handle) delete_menu(font_handle);
  376.   font_handle=create_menu("{FNM00}");
  377.   i=0;
  378.   while(getfontname(i,s))
  379.   {
  380.    sub=getfontsubname(i,1,0,r);
  381.    addentryl_menu(font_handle,"font_entry","font_flags",sub?"font_submenu":"","",s);
  382.    i++;
  383.   }
  384.  }
  385.  return(font_handle);
  386. }
  387.  
  388. int textfont_menu(int open)
  389. {
  390.  caretcontext();
  391.  return(font_menu(open));
  392. }
  393.  
  394. /****************************************************************/
  395.  
  396. int size_handle;
  397. int usize0,usize1,usize2,usize3,usize4,usize5,usize6;
  398.  
  399. int size_entry(int entry,int subcode)
  400. {
  401.  int usize;
  402.  
  403.  switch(entry)
  404.  {
  405.   case 0:
  406.          usize=usize0;
  407.          break;
  408.   case 1:
  409.          usize=usize1;
  410.          break;
  411.   case 2:
  412.          usize=usize2;
  413.          break;
  414.   case 3:
  415.          usize=usize3;
  416.          break;
  417.   case 4:
  418.          usize=usize4;
  419.          break;
  420.   case 5:
  421.          usize=usize5;
  422.          break;
  423.   case 6:
  424.          usize=usize6;
  425.          break;
  426.   case 7:
  427.          usize=stringu(string_menu(size_handle,7),2);
  428.          break;
  429.  }
  430.  setfontsize(usize);
  431.  return(0);
  432. }
  433.  
  434. int size_flags(int entry,string & text)
  435. {
  436.  int size;
  437.  int usize;
  438.  
  439.  size=getfontsize();
  440.  
  441.  switch(entry)
  442.  {
  443.   case 0:
  444.          tick=0;
  445.          usize=usize0;
  446.          break;
  447.   case 1:
  448.          usize=usize1;
  449.          break;
  450.   case 2:
  451.          usize=usize2;
  452.          break;
  453.   case 3:
  454.          usize=usize3;
  455.          break;
  456.   case 4:
  457.          usize=usize4;
  458.          break;
  459.   case 5:
  460.          usize=usize5;
  461.          break;
  462.   case 6:
  463.          usize=usize6;
  464.          break;
  465.   case 7:
  466.          usize=size;
  467.          break;
  468.  }
  469.  if(entry == 7 && size == -1) tick = 1;
  470.  text=(entry==7 && tick) ? "" : ustring(usize,2);
  471.  
  472.  if(entry==7) return((8<<24)|(8<<16)|WRITEABLE|!tick);
  473.  if(usize==size) return(tick=1);
  474.  return(0);
  475. }
  476.  
  477. int size_menu(int open)
  478. {
  479.  return(size_handle);
  480. }
  481.  
  482. /***************************************************************/
  483.  
  484. int effx_handle;
  485.  
  486. int effx_entry(int entry,int subcode)
  487. {
  488.  seteffect(1<<entry);
  489.  return(0);
  490. }
  491.  
  492. int effx_flags(int entry,string & text)
  493. {
  494.  return((geteffect() & (1<<entry))!=0);
  495. }
  496.  
  497. int effx_menu(int open)
  498. {
  499.  return(effx_handle);
  500. }
  501.  
  502. /****************************************************************/
  503.  
  504. int bullet_handle;
  505. int bulletformat;
  506.  
  507. int bullet_entry(int entry,int subcode)
  508. {
  509.  switch(entry)
  510.  {
  511.   case 0:
  512.   case 1:
  513.   case 2:
  514.   case 3:
  515.   case 4:
  516.          bulletformat&=~0xF;
  517.          bulletformat|=entry;
  518.          break;
  519.   case 5:
  520.   case 6:
  521.   case 7:
  522.          bulletformat&=~0xF0;
  523.          bulletformat|=(entry-5)<<4;
  524.          break;
  525.  }
  526.  setnumberformat(bulletformat);
  527.  return(0);
  528. }
  529.  
  530. int bullet_flags(int entry,string & text)
  531. {
  532.  int code;
  533.  code=0;
  534.  
  535.  if(entry==0) bulletformat=getnumberformat();
  536.  
  537.  switch(entry)
  538.  {
  539.   case 4:
  540.          code=DOTTED;
  541.   case 0:
  542.   case 1:
  543.   case 2:
  544.   case 3:
  545.          code|=(bulletformat & 0xF)==entry;
  546.          break;
  547.   case 5:
  548.   case 6:
  549.   case 7:
  550.          code=(bulletformat & 0xF0)==((entry-5)<<4);
  551.          break;
  552.  }
  553.  return(code);
  554. }
  555.  
  556. int bullet_menu(int open)
  557. {
  558.  return(bullet_handle);
  559. }
  560.  
  561. /****************************************************************/
  562.  
  563. int userstyle_handle;
  564.  
  565. int userstyle_entry(int entry,int subcode)
  566. {
  567.  setuserstyle(entry);
  568.  return(0);
  569. }
  570.  
  571. int userstyle_flags(int entry,string & text)
  572. {
  573.  return(isuserstyle(entry));
  574. }
  575.  
  576. int userstyle_menu(int open)
  577. {
  578.  int    i;
  579.  string s;
  580.  
  581.  if(userstyle_handle) delete_menu(userstyle_handle);
  582.  userstyle_handle=create_menu("{BSM00}");
  583.  
  584.  i=0;
  585.  while(getuserstyle(i++,s,0))
  586.   addentryl_menu(userstyle_handle,"userstyle_entry","userstyle_flags","","",s);
  587.  
  588.  return(userstyle_handle);
  589. }
  590.  
  591. /****************************************************************/
  592.  
  593. int align_handle;
  594.  
  595. int align_entry(int entry,int subcode)
  596. {
  597.  setalign(entry);
  598.  return(0);
  599. }
  600.  
  601. int align_flags(int entry,string & text)
  602. {
  603.  return(entry==getalign());
  604. }
  605.  
  606. int align_menu(int open)
  607. {
  608.  return(align_handle);
  609. }
  610.  
  611. /****************************************************************/
  612.  
  613. int lead_handle;
  614.  
  615. int lead_entry(int entry,int subcode)
  616. {
  617.  switch(entry)
  618.  {
  619.   case 0:
  620.          setleading("20%");
  621.          break;
  622.   case 1:
  623.          setleading("120%");
  624.          break;
  625.   case 2:
  626.          setleading(string_menu(lead_handle,2));
  627.          break;
  628.  }
  629.  return(0);
  630. }
  631.  
  632. int lead_flags(int entry,string & text)
  633. {
  634.  string s;
  635.  
  636.  getleading(s);
  637.  
  638.  switch(entry)
  639.  {
  640.   case 0:
  641.          tick=0;
  642.          if(s=="20%") return(tick=1);
  643.          break;
  644.   case 1:
  645.          if(s=="120%") return(tick=1);
  646.          break;
  647.   case 2: 
  648.          text=tick ? "" : s;
  649.          return((8<<24)|(8<<16)|WRITEABLE|!tick);
  650.          break;
  651.  }
  652.  return(0);
  653. }
  654.  
  655. int lead_menu(int open)
  656. {
  657.  return(lead_handle);
  658. }
  659.  
  660. /****************************************************************/
  661.  
  662. int rulewidth_handle;
  663. int urwidth0,urwidth1,urwidth2,urwidth3,urwidth4,urwidth5;
  664.  
  665. int rulewidth_entry(int entry,int subcode)
  666. {
  667.  int uwidth;
  668.  
  669.  switch(entry)
  670.  {
  671.   case 0:
  672.          uwidth=urwidth0;
  673.          break;
  674.   case 1:
  675.          uwidth=urwidth1;
  676.          break;
  677.   case 2:
  678.          uwidth=urwidth2;
  679.          break;
  680.   case 3:
  681.          uwidth=urwidth3;
  682.          break;
  683.   case 4:
  684.          uwidth=urwidth4;
  685.          break;
  686.   case 5:
  687.          uwidth=urwidth5;
  688.          break;
  689.   case 6:
  690.          uwidth=stringu(string_menu(rulewidth_handle,6),-1);
  691.          break;
  692.  }
  693.  setrulewidth(uwidth);
  694.  return(0);
  695. }
  696.  
  697. int rulewidth_flags(int entry,string & text)
  698. {
  699.  int width;
  700.  int uwidth;
  701.  
  702.  width=getrulewidth();
  703.  
  704.  switch(entry)
  705.  {
  706.   case 0:
  707.          tick=0;
  708.          uwidth=urwidth0;
  709.          break;
  710.   case 1:
  711.          uwidth=urwidth1;
  712.          break;
  713.   case 2:
  714.          uwidth=urwidth2;
  715.          break;
  716.   case 3:
  717.          uwidth=urwidth3;
  718.          break;
  719.   case 4:
  720.          uwidth=urwidth4;
  721.          break;
  722.   case 5:
  723.          uwidth=urwidth5;
  724.          break;
  725.   case 6:
  726.          uwidth=width;
  727.          break;
  728.  }
  729.  if(uwidth || entry==6)
  730.   text=ustring(uwidth,-1);
  731.  else
  732.  {
  733.   text="{THIN}";
  734.   translate(text);
  735.  }
  736.  if(entry==6 && tick) text="";
  737.  
  738.  if(entry==6) return((8<<24)|(8<<16)|WRITEABLE|!tick);
  739.  if(uwidth==width) return(tick=1);
  740.  return(0);        
  741. }
  742.  
  743. int rulewidth_menu(int open)
  744. {
  745.  return(rulewidth_handle);
  746. }
  747.  
  748. /****************************************************************/
  749.  
  750. int picture_handle;
  751.  
  752. int picture_menu(int open)
  753. {
  754.  return(picture_handle);
  755. }
  756.  
  757. /****************************************************************/
  758.  
  759. int style_handle;
  760.  
  761. int style_entry(int entry,int subcode)
  762. {
  763.  if(entry==0) openstylebox(0);
  764.  else
  765.  if(entry>=2) addstyle(entry-2);
  766.  
  767.  return(0);
  768. }
  769.  
  770.  
  771. int style_flags(int entry,string & text)
  772. {
  773.  int bits;
  774.  
  775.  bits=(activetype(TEXTFRAME)>1)?0:SHADED;
  776.  
  777.  if(entry==1) return(DOTTED|bits);
  778.  else         return(iscurrentstyle(entry-2)|bits);
  779. }
  780.  
  781.  
  782. int style_menu(int open)
  783. {
  784.  int    i;
  785.  string s;
  786.  
  787.  if(style_handle) delete_menu(style_handle);
  788.  style_handle=create_menu("{SM00}");
  789.  
  790.  addentry_menu(style_handle,"style_entry","","","CS_E","{SM01}");
  791.  addentry_menu(style_handle,"","style_flags","remove_menu","","{SM02}");
  792.  i=0;
  793.  while(getuserstyle(i++,s,1))
  794.   addentryl_menu(style_handle,"style_entry","style_flags","","",s);
  795.  
  796.  return(style_handle);
  797. }
  798.  
  799. /****************************************************************/
  800.  
  801. int scope_handle;
  802.  
  803. int scope_entry(int entry,int subcode)
  804. {
  805.  setscope(entry);
  806.  return(0);
  807. }
  808.  
  809. int scope_flags(int entry,string & text)
  810. {
  811.  return(entry==getscope());
  812. }
  813.  
  814. int scope_menu(int open)
  815. {
  816.  return(scope_handle);
  817. }
  818.  
  819. /****************************************************************/
  820.  
  821. int remove_handle;
  822.  
  823. int remove_entry(int entry,int subcode)
  824. {
  825.  string s;
  826.  
  827.  remstyle(entry-2);
  828.  getcurrentstyle(0,s,2);
  829.  rementry_menu(remove_handle,entry);
  830.  return(0);
  831. }
  832.  
  833. int remove_effects(int entry,int subcode)
  834. {
  835.  cleareffects(0);
  836.  return(0);
  837. }
  838.  
  839. int remove_styles(int entry,int subcode)
  840. {
  841.  int i = 0;
  842.  string s;
  843.  
  844.  cleareffects(0);
  845.  while(getcurrentstyle(i, s, 2))
  846.  {
  847.   remstyle(i++);
  848.   rementry_menu(remove_handle, 2);
  849.  }
  850.  return(0);
  851. }
  852.  
  853. int remove_flags(int entry,string & text)
  854. {
  855.  return(DOTTED);
  856. }
  857.  
  858. int remove_menu(int open)
  859. {
  860.  int    i;
  861.  string s;
  862.  
  863.  if(remove_handle) delete_menu(remove_handle);
  864.  remove_handle = create_menu("{RMM00}");
  865.  
  866.  addentry_menu(remove_handle,"remove_styles","","","C_A","{RMM01}");
  867.  addentry_menu(remove_handle,"remove_effects","remove_flags","","C_L","{RMM02}");
  868.  i = 0;
  869.  while(getcurrentstyle(i++, s, 2))
  870.   addentryl_menu(remove_handle,"remove_entry","","","",s);
  871.  
  872.  return(remove_handle);
  873. }
  874.  
  875. /****************************************************************/
  876.  
  877. int object_handle;
  878.  
  879. int object_entry(int entry,int subcode)
  880. {
  881.  switch(entry)
  882.  {
  883.  
  884.   case 4:
  885.          if(subcode==-1) openduplicatebox();
  886.          else            duplicateselection(-1,0,0);
  887.          break;
  888.   case 5:
  889.          if(cangroup()) groupselection();
  890.          else           ungroupselection();
  891.          break;
  892.   case 6:
  893.          if(canmakelocal()) makeselectionlocal();
  894.          else               makeselectionmaster();
  895.          break;
  896.  }
  897.  return(0);
  898. }
  899.  
  900. int object_flags(int entry,string & text)
  901. {
  902.  int bits;
  903.  
  904.  bits=SHADED;
  905.  
  906.  switch(entry)
  907.  {
  908.  
  909.   case 0:
  910.   case 1:
  911.   case 2:
  912.   case 9:
  913.          if(canmodify()) bits=0;
  914.          break;
  915.  
  916.   case 4:
  917.          if(canduplicate()) bits=0;
  918.          break;
  919.  
  920.   case 3:
  921.          if(canshape()) bits=DOTTED;
  922.          else           bits=DOTTED|SHADED;
  923.          break;
  924.  
  925.   case 7:
  926.          if(cangofront()) bits=0;
  927.          break;
  928.  
  929.   case 8:
  930.          if(cangoback()) bits=0;
  931.          break;
  932.  
  933.   case 5:
  934.          if(cangroup())
  935.          {
  936.           text="{OM06}";
  937.           translate(text);
  938.          }
  939.          else
  940.          if(canungroup())
  941.          {
  942.           text="{OM11}";
  943.           translate(text);
  944.          }
  945.          else                break;
  946.          bits=0;
  947.          break;
  948.  
  949.   case 6:
  950.          bits|=DOTTED;
  951.          if(canmakelocal())
  952.          {
  953.           text="{OM07}";
  954.           translate(text);
  955.          }
  956.          else
  957.          if(canmakemaster())
  958.          {
  959.           text="{OM12}";
  960.           translate(text);
  961.          }
  962.          else                break;
  963.          bits=DOTTED;
  964.          break;
  965.  }
  966.  
  967.  return(bits);
  968. }
  969.  
  970. int object_menu(int open)
  971. {
  972.  return(object_handle);
  973. }
  974.  
  975. /****************************************************************/
  976.  
  977. int valign_handle;
  978.  
  979. int valign_entry(int entry,int subcode)
  980. {
  981.  setvalign(entry);
  982.  return(0);
  983. }
  984.  
  985. int valign_flags(int entry,string & text)
  986. {
  987.  return(entry==getvalign());
  988. }
  989.  
  990. int valign_menu(int open)
  991. {
  992.  return(valign_handle);
  993. }
  994.  
  995. /****************************************************************/
  996.  
  997. int guidewidth_handle;
  998. int ugwidth0,ugwidth1,ugwidth2,ugwidth3,ugwidth4,ugwidth5;
  999.  
  1000. int guidewidth_entry(int entry,int subcode)
  1001. {
  1002.  int uwidth;
  1003.  
  1004.  switch(entry)
  1005.  {
  1006.   case 0:
  1007.          uwidth=ugwidth0;
  1008.          break;
  1009.   case 1:
  1010.          uwidth=ugwidth1;
  1011.          break;
  1012.   case 2:
  1013.          uwidth=ugwidth2;
  1014.          break;
  1015.   case 3:
  1016.          uwidth=ugwidth3;
  1017.          break;
  1018.   case 4:
  1019.          uwidth=ugwidth4;
  1020.          break;
  1021.   case 5:
  1022.          uwidth=ugwidth5;
  1023.          break;
  1024.   case 6:
  1025.          uwidth=stringu(string_menu(guidewidth_handle,6),-1);
  1026.          break;
  1027.  }
  1028.  setguidewidth(uwidth);
  1029.  return(0);
  1030. }
  1031.  
  1032. int guidewidth_flags(int entry,string & text)
  1033. {
  1034.  int width;
  1035.  int uwidth;
  1036.  
  1037.  width=getguidewidth();
  1038.  
  1039.  switch(entry)
  1040.  {
  1041.   case 0:
  1042.          tick=0;
  1043.          uwidth=ugwidth0;
  1044.          break;
  1045.   case 1:
  1046.          uwidth=ugwidth1;
  1047.          break;
  1048.   case 2:
  1049.          uwidth=ugwidth2;
  1050.          break;
  1051.   case 3:
  1052.          uwidth=ugwidth3;
  1053.          break;
  1054.   case 4:
  1055.          uwidth=ugwidth4;
  1056.          break;
  1057.   case 5:
  1058.          uwidth=ugwidth5;
  1059.          break;
  1060.   case 6:
  1061.          uwidth=width;
  1062.          break;
  1063.  }
  1064.  if(uwidth || entry==6)
  1065.   text=ustring(uwidth,-1);
  1066.  else
  1067.  {
  1068.   text="{THIN}";
  1069.   translate(text);
  1070.  }
  1071.  if(entry==6 && tick) text="";
  1072.  
  1073.  if(entry==6) return((8<<24)|(8<<16)|WRITEABLE|!tick);
  1074.  if(uwidth==width) return(tick=1);
  1075.  return(0);
  1076. }
  1077.  
  1078. int guidewidth_menu(int open)
  1079. {
  1080.  return(guidewidth_handle);
  1081. }
  1082.  
  1083. /****************************************************************/
  1084.  
  1085. int linewidth_handle;
  1086. int lwidth0,lwidth1,lwidth2,lwidth3,lwidth4,lwidth5;
  1087.  
  1088. int linewidth_entry(int entry,int subcode)
  1089. {
  1090.  int uwidth;
  1091.  
  1092.  switch(entry)
  1093.  {
  1094.   case 0:
  1095.          uwidth=lwidth0;
  1096.          break;
  1097.   case 1:
  1098.          uwidth=lwidth1;
  1099.          break;
  1100.   case 2:
  1101.          uwidth=lwidth2;
  1102.          break;
  1103.   case 3:
  1104.          uwidth=lwidth3;
  1105.          break;
  1106.   case 4:
  1107.          uwidth=lwidth4;
  1108.          break;
  1109.   case 5:
  1110.          uwidth=lwidth5;
  1111.          break;
  1112.   case 6:
  1113.          uwidth=stringu(string_menu(linewidth_handle,6),-1);
  1114.          break;
  1115.  }
  1116.  setlinewidth(uwidth);
  1117.  return(0);
  1118. }
  1119.  
  1120. int linewidth_flags(int entry,string & text)
  1121. {
  1122.  int width;
  1123.  int uwidth;
  1124.  
  1125.  width=getlinewidth();
  1126.  
  1127.  switch(entry)
  1128.  {
  1129.   case 0:
  1130.          tick=0;
  1131.          uwidth=lwidth0;
  1132.          break;
  1133.   case 1:
  1134.          uwidth=lwidth1;
  1135.          break;
  1136.   case 2:
  1137.          uwidth=lwidth2;
  1138.          break;
  1139.   case 3:
  1140.          uwidth=lwidth3;
  1141.          break;
  1142.   case 4:
  1143.          uwidth=lwidth4;
  1144.          break;
  1145.   case 5:
  1146.          uwidth=lwidth5;
  1147.          break;
  1148.   case 6:
  1149.          uwidth=width;
  1150.          break;
  1151.  }
  1152.  if(uwidth || entry==6)
  1153.   text=ustring(uwidth,-1);
  1154.  else
  1155.  {
  1156.   text="{THIN}";
  1157.   translate(text);
  1158.  }
  1159.  if(entry==6 && tick) text="";
  1160.  
  1161.  if(entry==6) return((8<<24)|(8<<16)|WRITEABLE|!tick);
  1162.  if(uwidth==width) return(tick=1);
  1163.  return(0);     
  1164. }
  1165.  
  1166. int linewidth_menu(int open)
  1167. {
  1168.  return(linewidth_handle);
  1169. }
  1170.  
  1171. /****************************************************************/
  1172.  
  1173. int linestyle_handle;
  1174.  
  1175. int linestyle_entry(int entry,int subcode)
  1176. {
  1177.  int ustyle;
  1178.  int l;
  1179.  
  1180.  switch(entry)
  1181.  {
  1182.   case 0:
  1183.          ustyle=0xFFFFFFFF;
  1184.          l = 5120;
  1185.          break;
  1186.   case 1:
  1187.          ustyle=0xFCFCFCFC;
  1188.          l = 2880;
  1189.          break;
  1190.   case 2:
  1191.          ustyle=0xEEEEEEEE;
  1192.          l = 3840;
  1193.          break;
  1194.   case 3:
  1195.          ustyle=0xAAAAAAAA;
  1196.          l = 5120;
  1197.          break;
  1198.   case 4:
  1199.          ustyle=0xFAFAFAFA;
  1200.          l = 3200;
  1201.          break;
  1202.  }
  1203.  setlinepattern(ustyle,l);
  1204.  return(0);
  1205. }
  1206.  
  1207. int linestyle_flags(int entry,string & text)
  1208. {
  1209.  int style;
  1210.  int scale;
  1211.  int ustyle;
  1212.  int l;
  1213.  
  1214.  style=getlinepattern();
  1215.  scale=getlinescale();
  1216.  
  1217.  switch(entry)
  1218.  {
  1219.   case 0:
  1220.          ustyle=0xFFFFFFFF;
  1221.          l = 5120;
  1222.          break;
  1223.   case 1:
  1224.          ustyle=0xFCFCFCFC;
  1225.          l = 2880;
  1226.          break;
  1227.   case 2:
  1228.          ustyle=0xEEEEEEEE;
  1229.          l = 3840;
  1230.          break;
  1231.   case 3:
  1232.          ustyle=0xAAAAAAAA;
  1233.          l = 5120;
  1234.          break;
  1235.   case 4:
  1236.          ustyle=0xFAFAFAFA;
  1237.          l = 3200;
  1238.          break;
  1239.  }
  1240.  return(style==ustyle && scale==l);
  1241. }
  1242.  
  1243. int linestyle_menu(int open)
  1244. {
  1245.  return(linestyle_handle);
  1246. }
  1247.  
  1248. /****************************************************************/
  1249.  
  1250. int linejoin_handle;
  1251.  
  1252. int linejoin_entry(int entry,int subcode)
  1253. {
  1254.  setlinejoin(entry);
  1255.  return(0);
  1256. }
  1257.  
  1258. int linejoin_flags(int entry,string & text)
  1259. {
  1260.  int join;
  1261.  join=getlinejoin();
  1262.  return(join==entry);
  1263. }
  1264.  
  1265. int linejoin_menu(int open)
  1266. {
  1267.  return(linejoin_handle);
  1268. }
  1269.  
  1270. /****************************************************************/
  1271.  
  1272. int caps_handle;
  1273. int trianglew_handle;
  1274. int triangleh_handle;
  1275. int tstart;
  1276. int theight;
  1277. int thandle;
  1278. int umult0,umult1,umult2,umult3;
  1279.  
  1280. int linestartcaps_handle;
  1281.  
  1282. int sc_entry(int entry,int subcode)
  1283. {
  1284.  setlinecaps(tstart,entry);
  1285.  return(0);
  1286. }
  1287.  
  1288. int sc_flags(int entry,string & text)
  1289. {
  1290.  tstart=1;
  1291.  return(getlinecaps(tstart)==entry);
  1292. }
  1293.  
  1294. int linestartcaps_menu(int open)
  1295. {
  1296.  return(linestartcaps_handle);
  1297. }
  1298.  
  1299. /****************************************************************/
  1300.  
  1301. int lineendcaps_handle;
  1302.  
  1303. int ec_entry(int entry,int subcode)
  1304. {
  1305.  setlinecaps(tstart,entry);
  1306.  return(0);
  1307. }
  1308.  
  1309. int ec_flags(int entry,string & text)
  1310. {
  1311.  tstart=0;
  1312.  return(getlinecaps(tstart)==entry);
  1313. }
  1314.  
  1315. int lineendcaps_menu(int open)
  1316. {
  1317.  return(lineendcaps_handle);
  1318. }
  1319.  
  1320. /****************************************************************/
  1321.  
  1322. int caps_menu(int open)
  1323. {
  1324.  return(caps_handle);
  1325. }
  1326.  
  1327. /****************************************************************/
  1328.  
  1329. int triangle_entry(int entry,int subcode)
  1330. {
  1331.  int umultiple;
  1332.  
  1333.  
  1334.  switch(entry)
  1335.  {
  1336.   case 0:
  1337.          umultiple=umult0;
  1338.          break;
  1339.   case 1:
  1340.          umultiple=umult1;
  1341.          break;
  1342.   case 2:
  1343.          umultiple=umult2;
  1344.          break;
  1345.   case 3:
  1346.          umultiple=umult3;
  1347.          break;
  1348.   case 4:
  1349.          umultiple=stringdp(string_menu(thandle,4));
  1350.          break;
  1351.  }
  1352.  setlinetriangle(tstart,theight,umultiple);
  1353.  return(0);
  1354. }
  1355.  
  1356. int triangle_flags(int entry,string & text)
  1357. {
  1358.  int umultiple;
  1359.  int multiple;
  1360.  
  1361.  multiple=getlinetriangle(tstart,theight);
  1362.  
  1363.  switch(entry)
  1364.  {
  1365.   case 0:
  1366.          tick=0;
  1367.          umultiple=umult0;
  1368.          break;
  1369.   case 1:
  1370.          umultiple=umult1;
  1371.          break;
  1372.   case 2:
  1373.          umultiple=umult2;
  1374.          break;
  1375.   case 3:
  1376.          umultiple=umult3;
  1377.          break;
  1378.   case 4:
  1379.          text=tick ? "" : dpstring(multiple,2);
  1380.          return((8<<24)|(8<<16)|WRITEABLE|!tick);
  1381.          break;
  1382.  }
  1383.  text="x"+dpstring(umultiple,2);
  1384.  if(multiple==umultiple) return(tick=1);
  1385.  return(0); 
  1386. }
  1387.  
  1388. /****************************************************************/
  1389.  
  1390. int trianglew_flags(int entry,string & text)
  1391. {
  1392.  theight=0;
  1393.  thandle=trianglew_handle;
  1394.  return(triangle_flags(entry,text));
  1395. }
  1396.  
  1397. int trianglew_menu(int open)
  1398. {
  1399.  return(trianglew_handle);
  1400. }
  1401.  
  1402. /****************************************************************/
  1403.  
  1404. int triangleh_flags(int entry,string & text)
  1405. {
  1406.  theight=1;
  1407.  thandle=triangleh_handle;
  1408.  return(triangle_flags(entry,text));
  1409. }
  1410.  
  1411. int triangleh_menu(int open)
  1412. {
  1413.  return(triangleh_handle);
  1414. }
  1415.  
  1416. /****************************************************************/
  1417.  
  1418. int page_handle;
  1419.  
  1420. int page_flags(int entry,string & text)
  1421. {
  1422.  switch(entry)
  1423.  {
  1424.   case 0:
  1425.   case 3:
  1426.   case 5:
  1427.   case 6:
  1428.          return(ismasterview()?SHADED:0);
  1429.          break;
  1430.   case 1:
  1431.          return(ismasterview()?DOTTED:SHADED | DOTTED);
  1432.          break;
  1433.   case 4:
  1434.          return DOTTED;
  1435.          break;
  1436.  }
  1437.  
  1438.  return(0);
  1439. }
  1440.  
  1441. int page_entry(int entry,int subcode)
  1442. {
  1443.  switch(entry)
  1444.  {
  1445.   case 0:
  1446.          newview(1);
  1447.          break;
  1448.  }
  1449.  return(0);
  1450. }
  1451.  
  1452. int page_menu(int open)
  1453. {
  1454.  return(page_handle);
  1455. }
  1456.  
  1457. /****************************************************************/
  1458.  
  1459. int newpagesize_handle;
  1460.  
  1461. int newpagesize_entry(int entry,int subcode)
  1462. {
  1463.  string s;
  1464.  
  1465.  switch(entry)
  1466.  {
  1467.   case 0:
  1468.          s="{PSM01}";
  1469.          translate(s);
  1470.          setnewpagesize(841890,1190551,s,0);
  1471.          break;
  1472.   case 1:
  1473.          s="{PSM02}";
  1474.          translate(s);
  1475.          setnewpagesize(595276,841890,s,0);
  1476.          break;
  1477.   case 2:
  1478.          s="{PSM03}";
  1479.          translate(s);
  1480.          setnewpagesize(420944,595276,s,0);
  1481.          break;
  1482.   case 3:
  1483.          s="{PSM04}";
  1484.          translate(s);
  1485.          setnewpagesize(612000,792000,s,0);
  1486.          break;
  1487.   case 4:
  1488.          s="{PSM05}";
  1489.          translate(s);
  1490.          setnewpagesize(612000,1008000,s,0);
  1491.          break;
  1492.   case 5:
  1493.          s="{PSM06}";
  1494.          translate(s);
  1495.          setnewpagesize(792000,1224000,s,0);
  1496.          break;
  1497.   case 6:
  1498.          s="{PSM07}";
  1499.          translate(s);
  1500.          setnewpagesize(-1,-1,s,1);
  1501.          break;
  1502.  }
  1503.  return(0);
  1504. }
  1505.  
  1506. int newpagesize_flags(int entry,string & text)
  1507. {
  1508.  int x;
  1509.  int y;
  1510.  int code;
  1511.  
  1512.  x=getnewpagesize(0);
  1513.  y=getnewpagesize(1);
  1514.  
  1515.  switch(entry)
  1516.  {
  1517.   case 0:
  1518.          code=(x==841890 && y==1190551);
  1519.          break;
  1520.   case 1:
  1521.          code=(x==595276 && y==841890);
  1522.          break;
  1523.   case 2:
  1524.          code=(x==420944 && y==595276);
  1525.          break;
  1526.   case 3:
  1527.          code=(x==612000 && y==792000);
  1528.          break;
  1529.   case 4:
  1530.          code=(x==612000 && y==1008000);
  1531.          break;
  1532.   case 5:
  1533.          code=(x==792000 && y==1224000);
  1534.          break;
  1535.   case 6:
  1536.          code=(x==-1 && y==-1);
  1537.          break;
  1538.  }
  1539.  return(code);
  1540. }
  1541.  
  1542. int newpagesize_menu(int open)
  1543. {
  1544.  return(newpagesize_handle);
  1545. }
  1546.  
  1547. /****************************************************************/
  1548.  
  1549. int newchapter_handle;
  1550.  
  1551. int newchapter_entry(int entry,int subcode)
  1552. {
  1553.  opennewchapterbox(entry);
  1554.  return(0);
  1555. }
  1556.  
  1557. int newchapter_menu(int open)
  1558. {
  1559.  return(newchapter_handle);
  1560. }
  1561.  
  1562. /****************************************************************/
  1563.  
  1564. int misc_handle;
  1565.  
  1566. int misc_entry(int entry,int subcode)
  1567. {
  1568.  switch(entry)
  1569.  {
  1570.   case 4:
  1571.          openeditcolourbox(0);
  1572.          break;
  1573.  }
  1574.  return(0);
  1575. }
  1576.  
  1577. int misc_flags(int entry,string & text)
  1578. {
  1579.  return((activetype(TEXTFRAME)>1)?0:SHADED);
  1580. }
  1581.  
  1582. int misc_menu(int open)
  1583. {
  1584.  return(misc_handle);
  1585. }
  1586.  
  1587. /****************************************************************/
  1588.  
  1589. int spell_handle;
  1590.  
  1591. int spell_entry(int entry,int subcode)
  1592. {
  1593.  switch(entry)
  1594.  {
  1595.   case 0:
  1596.          checkstory(0);
  1597.          break;
  1598.   case 3:
  1599.          checkstory(1);
  1600.          break;
  1601.   case 4:
  1602.          setcheck(getcheck()^1);
  1603.          break;
  1604.  
  1605.  }
  1606. }
  1607.  
  1608. int spell_flags(int entry,string & text)
  1609. {
  1610.  switch(entry)
  1611.  {
  1612.   case 0:
  1613.   case 1:
  1614.   case 3:
  1615.          return((activetype(TEXTFRAME)>1)?0:SHADED);
  1616.  
  1617.   case 4:
  1618.          return((getcheck()&0x1)|DOTTED);
  1619.          break;
  1620.  }
  1621.  return(0);
  1622. }
  1623.  
  1624. int spell_menu(int open)
  1625. {
  1626.  return(spell_handle);
  1627. }
  1628.  
  1629. /****************************************************************/
  1630.  
  1631. int userdict_handle;
  1632.  
  1633. int userdict_entry(int entry,int subcode)
  1634. {
  1635.  setuserdict(entry);
  1636.  return(0);
  1637. }
  1638.  
  1639. int userdict_flags(int entry,string & text)
  1640. {
  1641.  return(isuserdict(entry));
  1642. }
  1643.  
  1644. int userdict_menu(int open)
  1645. {
  1646.  int    i;
  1647.  string s;
  1648.  
  1649.  if(userdict_handle) delete_menu(userdict_handle);
  1650.  userdict_handle=create_menu("{DM00}");
  1651.  
  1652.  i=0;
  1653.  while(getuserdict(i++,s))
  1654.   addentryl_menu(userdict_handle,"userdict_entry","userdict_flags","","",s);
  1655.  
  1656.  return(userdict_handle);
  1657. }
  1658.  
  1659. /****************************************************************/
  1660.  
  1661. int insert_handle;
  1662.  
  1663. int insert_entry(int entry,int subcode)
  1664. {
  1665.  switch(entry)
  1666.  {
  1667.   case 0:
  1668.          type("{chapternumber}");
  1669.          break;
  1670.   case 1:
  1671.          type("{pagenumber}");
  1672.          break;
  1673.   case 2:
  1674.          type(datestring());
  1675.          break;
  1676.   case 3:
  1677.          type("{activedate}");
  1678.          break;
  1679.   case 4:
  1680.          type(timestring());
  1681.          break;
  1682.   case 5:
  1683.          type("{newpage}");
  1684.          break;
  1685.   case 6:
  1686.          type("{newline}");
  1687.          break;
  1688.   case 7:
  1689.          type("{hardspace}");
  1690.          break;
  1691.   case 8:
  1692.          type("{hardhyphen}");
  1693.          break;
  1694.   case 9:
  1695.          type("{softhyphen}");
  1696.          break;
  1697.  }
  1698. }
  1699.  
  1700. int insert_flags(int entry,string & text)
  1701. {
  1702.  return((activetype(TEXTFRAME)>1)?0:SHADED);
  1703. }
  1704.  
  1705. int insert_menu(int open)
  1706. {
  1707.  return(insert_handle);
  1708. }
  1709.  
  1710. /****************************************************************/
  1711.  
  1712. int units_handle;
  1713.  
  1714. int units_entry(int entry,int subcode)
  1715. {
  1716.  setunits(entry);
  1717.  return(0);
  1718. }
  1719.  
  1720. int units_flags(int entry,string & text)
  1721. {
  1722.  return(getunits()==entry);
  1723. }
  1724.  
  1725. int units_menu(int open)
  1726. {
  1727.  return(units_handle);
  1728. }
  1729.  
  1730. /****************************************************************/
  1731.  
  1732. int colour_handle;
  1733.  
  1734. int colour_entry(int entry,int subcode)
  1735. {
  1736.  setcolour(entry);
  1737.  return(0);
  1738. }
  1739.  
  1740. int colour_menu(int open)
  1741. {
  1742.  int    i;
  1743.  string s;
  1744.  
  1745.  if(colour_handle) delete_menu(colour_handle);
  1746.  colour_handle=create_menu("{CLM00}");
  1747.  
  1748.  i=0;
  1749.  while(getcolour(i++,s,0))
  1750.   addentryl_menu(colour_handle,"colour_entry","","","",s);
  1751.  
  1752.  return(colour_handle);
  1753. }
  1754.  
  1755. /****************************************************************/
  1756.  
  1757. int colourchart_handle;
  1758.  
  1759. int colourchart_flags(int entry,string & text)
  1760. {
  1761.  return(iscurrentchart(entry));
  1762. }
  1763.  
  1764. int colourchart_entry(int entry,int subcode)
  1765. {
  1766.  setcolourchart(entry);
  1767.  return(0);
  1768. }
  1769.  
  1770. int colourchart_menu(int open)
  1771. {
  1772.  return(colourchart_handle);
  1773. }
  1774.  
  1775. /****************************************************************/
  1776.  
  1777. int info_handle;
  1778.  
  1779. int info_entry(int entry,int subcode)
  1780. {
  1781.  switch(entry)
  1782.  {
  1783.   case 2:
  1784.          setclipboard(getclipboard()^1);
  1785.          break;
  1786.  }
  1787.  return(0);
  1788. }
  1789.  
  1790. int info_menu(int open)
  1791. {
  1792.  return(info_handle);
  1793. }
  1794.  
  1795. /****************************************************************/
  1796.  
  1797. int script_handle;
  1798. int script_exists = 0;
  1799.  
  1800. int script_menu(int open)
  1801. {
  1802.  if(!script_handle)
  1803.   script_handle = create_menu("{APM00}");
  1804.  
  1805.  return(script_handle);
  1806. }
  1807.  
  1808. void script_menu_initialise(void)
  1809. {
  1810.  if(!(script_exists & 1))
  1811.  {
  1812.   addentry_menu(main_handle,"","","script_menu","","{APM00}");
  1813.   script_exists |= 1;
  1814.  }
  1815. }
  1816.  
  1817. /****************************************************************/
  1818.  
  1819. void main(void)
  1820. {
  1821.  remove_menu(1);
  1822.  style_menu(1);
  1823.  script_menu(1);
  1824. }
  1825.